package kk.json;

import java.util.List;
import java.util.Set;

import org.json.JSONArray;
import org.json.JSONObject;

/**
 * @author kkmike999
 * 
 * @描述 JSONDbBuffer所有操作，JSONArray都储存在缓冲区
 * 
 * */
public class JSONDbBuffer {

	private static JSONDb	db	= JSONDb.getInstance();

	/** 将clazz对应JSONArray读取到缓冲区(其实只要执行insert、delete、update、quer等函数，就自动从持久层读取到缓冲区了) */
	public <T> void readToBuffer(Class<T> clazz) {
		db.readJSONArray(clazz);
	}

	/** 读取JSONArray */
	public <T> JSONArray readJSONArray(Class<T> clazz) {
		return db.readJSONArray(clazz);
	}

	/**
	 * 
	 * 将对象以JSON形式储存到缓冲区
	 * 
	 * @see {@linkplain JSONDb#insert(Object, boolean)}
	 * 
	 * @param object
	 *            需要储存的对象
	 */
	public <T> void insert(T object) {
		db.insert(object, false);
	}

	public <T> void insert(JSONObject json, Class<T> clazz) {
		db.insert(clazz, json, false);
	}

	/**
	 * @see {@linkplain JSONDb#insert(List, boolean)}
	 * */
	public <T> void insert(List<T> list) {
		db.insert(list, false);
	}

	/**
	 * @see {@linkplain JSONDb#insert(Class, JSONObject, boolean)}
	 * */
	public <T> void insert(Class<T> clazz, JSONArray jsonArr) {
		db.insert(clazz, jsonArr, false);
	}

	/**
	 * 从缓冲区clazz对应JSONArray 删除特定元素
	 * 
	 * @param object
	 *            需要储存的对象
	 * 
	 * @param condition
	 *            筛选条件
	 * 
	 * @see {@linkplain JSONDb#delete(Class, boolean, Condition)}
	 * 
	 */
	public <T> void delete(Class<T> clazz, Condition condition) {
		db.delete(clazz, false, condition);
	}

	/***
	 * 删除clazz对应JSONArray
	 * 
	 * @param clazz
	 * @param writeToStorage
	 */
	public <T> void deleteAll(Class<T> clazz) {
		db.deleteAll(clazz, false);
	}

	/**
	 * 更新某个元素
	 * 
	 * @param object
	 *            需要更新的对象
	 * 
	 * @param condition
	 *            筛选条件
	 */
	public <T> void update(T object, Condition condition) {
		db.update(object, false, condition);
	}

	/***
	 * 查询所有操作
	 * 
	 * @param clazz
	 * @return
	 */
	public <T> List<T> queryAll(Class<T> clazz) {
		return queryByCondition(clazz, null);
	}

	/**
	 * 查询操作
	 * 
	 * @param clazz
	 * @param condition
	 * @return
	 */
	public <T> List<T> queryByCondition(Class<T> clazz, Condition condition) {

		List<T> queryList = db.queryByCondition(clazz, condition);

		return queryList;
	}

	/** 将缓冲区clazz数据写入持久层 */
	public <T> void flush(Class<T> clazz) {
		db.write(db.readJSONArray(clazz), clazz, true);
	}

	/** 将缓冲区全部数据写入持久层 */
	@SuppressWarnings("static-access")
	public <T> void flush() {
		Set<Class<?>> keys = db.jsonMap.keySet();

		for (Class<?> clazz : keys) {

			JSONArray jsonArray = db.jsonMap.get(clazz);

			db.write(jsonArray, clazz, true);
		}

	}
}
